home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / system-config-printer / options.py < prev    next >
Text File  |  2009-10-19  |  14KB  |  395 lines
  1. ## system-config-printer
  2.  
  3. ## Copyright (C) 2006, 2007, 2008 Red Hat, Inc.
  4. ## Copyright (C) 2008 Tim Waugh <twaugh@redhat.com>
  5. ## Copyright (C) 2006 Florian Festi <ffesti@redhat.com>
  6.  
  7. ## This program is free software; you can redistribute it and/or modify
  8. ## it under the terms of the GNU General Public License as published by
  9. ## the Free Software Foundation; either version 2 of the License, or
  10. ## (at your option) any later version.
  11.  
  12. ## This program is distributed in the hope that it will be useful,
  13. ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ## GNU General Public License for more details.
  16.  
  17. ## You should have received a copy of the GNU General Public License
  18. ## along with this program; if not, write to the Free Software
  19. ## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. import gtk
  22.  
  23. def OptionWidget(name, v, s, on_change):
  24.     if isinstance(v, list):
  25.         # XXX
  26.         if isinstance(s, list):
  27.             for vv in v + s:
  28.                 if not isinstance(vv, str): raise ValueError
  29.             return OptionSelectMany(name, v, s, on_change)
  30.         print v, s
  31.         raise NotImplemented
  32.     else:
  33.         if (isinstance(s, int) or
  34.             isinstance(s, float) or
  35.             (isinstance(s, tuple) and
  36.              len(s) == 2 and
  37.              ((isinstance(s[0], int) and isinstance(s[1], int)) or
  38.               (isinstance(s[0], float) and isinstance(s[1], float))))):
  39.             try:
  40.                 if (isinstance(s, int) or
  41.                     isinstance(s, tuple) and isinstance(s[0], int)):
  42.                     v = int(v)
  43.                 else:
  44.                     v = float(v)
  45.             except ValueError:
  46.                 return OptionText(name, v, "", on_change)
  47.             return OptionNumeric(name, v, s, on_change)
  48.         elif isinstance(s, list):
  49.             for sv in s:
  50.                 if not isinstance(sv, int):
  51.                     return OptionSelectOne(name, v, s, on_change)
  52.             try:
  53.                 v = int(v)
  54.             except ValueError:
  55.                 return OptionSelectOne(name, v, s, on_change)
  56.             return OptionSelectOneNumber(name, v, s, on_change)
  57.         elif isinstance(s, str):
  58.             return OptionText(name, v, s, on_change)
  59.         else:
  60.             raise ValueError
  61.  
  62. # ---------------------------------------------------------------------------
  63.  
  64. class OptionInterface:
  65.     def get_current_value(self):
  66.         raise NotImplemented
  67.  
  68.     def is_changed(self):
  69.         raise NotImplemented
  70.  
  71. class OptionAlwaysShown(OptionInterface):
  72.     # States
  73.     STATE_UNCHANGED=0
  74.     STATE_RESET=1
  75.     STATE_ADJUSTED=2
  76.  
  77.     def __init__(self, name, ipp_type, system_default,
  78.                  widget, button, combobox_map = None, use_supported = False):
  79.         self.name = name
  80.         self.widget = widget
  81.         self.button = button
  82.         if ipp_type == bool:
  83.             def bool_type (x):
  84.                 if type (x) == str:
  85.                     if x.lower () in ("false", "no", "off"):
  86.                         return False
  87.                     # Even the empty string is true.
  88.                     return True
  89.                 return bool (x)
  90.             ipp_type = bool_type
  91.         self.ipp_type = ipp_type
  92.         self.set_default (system_default)
  93.         self.combobox_map = combobox_map
  94.         if combobox_map != None and ipp_type == int:
  95.             model = self.widget.get_model ()
  96.             i = 0
  97.             dict = {}
  98.             iter = model.get_iter_first ()
  99.             while iter:
  100.                 dict[combobox_map[i]] = model.get_value (iter, 0)
  101.                 i += 1
  102.                 iter = model.iter_next (iter)
  103.             self.combobox_dict = dict
  104.         self.use_supported = use_supported
  105.         self.reinit (None)
  106.  
  107.     def set_default(self, system_default):
  108.         # For the media option, the system default depends on the printer's
  109.         # PageSize setting.  This method allows the main module to tell us
  110.         # what that is.
  111.         self.system_default = self.ipp_type (system_default)
  112.  
  113.     def reinit(self, original_value, supported=None):
  114.         """Set the original value of the option and the supported choices.
  115.         The special value None for original_value resets the option to the
  116.         system default."""
  117.         if (supported != None and
  118.             self.use_supported):
  119.             if (type(self.widget) == gtk.ComboBox and
  120.                 self.ipp_type == str):
  121.                 model = self.widget.get_model ()
  122.                 model.clear ()
  123.                 for each in supported:
  124.                     iter = model.append ()
  125.                     model.set_value (iter, 0, each)
  126.             elif (type(self.widget) == gtk.ComboBox and
  127.                   self.ipp_type == int and
  128.                   self.combobox_map != None):
  129.                 model = self.widget.get_model ()
  130.                 model.clear ()
  131.                 for each in supported:
  132.                     iter = model.append ()
  133.                     model.set_value (iter, 0, self.combobox_dict[each])
  134.         if original_value != None:
  135.             self.original_value = self.ipp_type (original_value)
  136.             self.set_widget_value (self.original_value)
  137.             self.button.set_sensitive (True)
  138.         else:
  139.             self.original_value = None
  140.             self.set_widget_value (self.system_default)
  141.             self.button.set_sensitive (False)
  142.         self.state = self.STATE_UNCHANGED
  143.  
  144.     def set_widget_value(self, ipp_value):
  145.         t = type(self.widget)
  146.         if t == gtk.SpinButton:
  147.             return self.widget.set_value (ipp_value)
  148.         elif t == gtk.ComboBox:
  149.             if self.ipp_type == str and self.combobox_map == None:
  150.                 model = self.widget.get_model ()
  151.                 iter = model.get_iter_first ()
  152.                 while (iter != None and
  153.                        model.get_value (iter, 0) != ipp_value):
  154.                     iter = model.iter_next (iter)
  155.                 if iter:
  156.                     self.widget.set_active_iter (iter)
  157.             else:
  158.                 # It's an int.
  159.                 if self.combobox_map:
  160.                     index = self.combobox_map.index (ipp_value)
  161.                 else:
  162.                     index = ipp_value
  163.                 return self.widget.set_active (index)
  164.         elif t == gtk.CheckButton:
  165.             return self.widget.set_active (ipp_value)
  166.         else:
  167.             raise NotImplemented
  168.  
  169.     def get_widget_value(self):
  170.         t = type(self.widget)
  171.         if t == gtk.SpinButton:
  172.             # Ideally we would use self.widget.get_value() here, but
  173.             # it doesn't work if the value has been typed in and then
  174.             # the Apply button immediately clicked.  To handle this,
  175.             # we use self.widget.get_text() and fall back to
  176.             # get_value() if the result cannot be interpreted as the
  177.             # type we expect.
  178.             try:
  179.                 return self.ipp_type (self.widget.get_text ())
  180.             except ValueError:
  181.                 # Can't convert result of get_text() to ipp_type.
  182.                 return self.ipp_type (self.widget.get_value ())
  183.         elif t == gtk.ComboBox:
  184.             if self.combobox_map:
  185.                 return self.combobox_map[self.widget.get_active()]
  186.             if self.ipp_type == str:
  187.                 return self.widget.get_active_text ()
  188.             return self.ipp_type (self.widget.get_active ())
  189.         elif t == gtk.CheckButton:
  190.             return self.ipp_type (self.widget.get_active ())
  191.  
  192.         print t
  193.         raise NotImplemented
  194.  
  195.     def get_current_value(self):
  196.         return self.get_widget_value ()
  197.  
  198.     def is_changed(self):
  199.         if self.original_value != None:
  200.             # There was a value set previously.
  201.             if self.state == self.STATE_RESET:
  202.                 # It's been removed.
  203.                 return True
  204.             if self.state == self.STATE_ADJUSTED:
  205.                 if self.get_current_value () != self.original_value:
  206.                     return True
  207.                 return False
  208.  
  209.             # The value is the same as before, and not reset.
  210.             return False
  211.  
  212.         # There was no original value set.
  213.         if self.state == self.STATE_ADJUSTED:
  214.             # It's been adjusted.
  215.             return True
  216.  
  217.         # It's been left alone, or possible adjusted and then reset.
  218.         return False
  219.  
  220.     def reset(self):
  221.         self.set_widget_value (self.system_default)
  222.         self.state = self.STATE_RESET
  223.         self.button.set_sensitive (False)
  224.  
  225.     def changed(self):
  226.         self.state = self.STATE_ADJUSTED
  227.         self.button.set_sensitive (True)
  228.  
  229. class OptionAlwaysShownSpecial(OptionAlwaysShown):
  230.     def __init__(self, name, ipp_type, system_default,
  231.                  widget, button, combobox_map = None, use_supported = False,
  232.                  special_choice = "System default"):
  233.         self.special_choice = special_choice
  234.         self.special_choice_shown = False
  235.         OptionAlwaysShown.__init__ (self, name, ipp_type, system_default,
  236.                                     widget, button,
  237.                                     combobox_map=combobox_map,
  238.                                     use_supported=use_supported)
  239.  
  240.     def show_special_choice (self):
  241.         if self.special_choice_shown:
  242.             return
  243.  
  244.         self.special_choice_shown = True
  245.         # Only works for ComboBox widgets
  246.         model = self.widget.get_model ()
  247.         iter = model.insert (0)
  248.         model.set_value (iter, 0, self.special_choice)
  249.         self.widget.set_active_iter (model.get_iter_first ())
  250.  
  251.     def hide_special_choice (self):
  252.         if not self.special_choice_shown:
  253.             return
  254.  
  255.         self.special_choice_shown = False
  256.         # Only works for ComboBox widgets
  257.         model = self.widget.get_model ()
  258.         model.remove (model.get_iter_first ())
  259.  
  260.     def reinit(self, original_value, supported=None):
  261.         if original_value != None:
  262.             self.hide_special_choice ()
  263.         else:
  264.             self.show_special_choice ()
  265.  
  266.         OptionAlwaysShown.reinit (self, original_value, supported=supported)
  267.  
  268.     def reset(self):
  269.         self.show_special_choice ()
  270.         OptionAlwaysShown.reset (self)
  271.  
  272.     def changed(self):
  273.         OptionAlwaysShown.changed (self)
  274.         if self.widget.get_active () > 0:
  275.             self.hide_special_choice ()
  276.  
  277. class Option(OptionInterface):
  278.  
  279.     conflicts = None
  280.  
  281.     def __init__(self, name, value, supported, on_change):
  282.         self.name = name
  283.         self.value = value
  284.         self.supported = supported
  285.         self.on_change = on_change
  286.         self.is_new = False
  287.  
  288.         label = name
  289.         if not label.endswith (':'):
  290.             label += ':'
  291.         self.label = gtk.Label(label)
  292.         self.label.set_alignment(0.0, 0.5)
  293.  
  294.     def get_current_value(self):
  295.         raise NotImplemented
  296.  
  297.     def is_changed(self):
  298.         return (self.is_new or
  299.                 str (self.get_current_value()) != str (self.value))
  300.  
  301.     def changed(self, widget, *args):
  302.         self.on_change(self)
  303.     
  304. # ---------------------------------------------------------------------------
  305.  
  306. class OptionSelectOne(Option):
  307.  
  308.     def __init__(self, name, value, supported, on_change):
  309.         Option.__init__(self, name, value, supported, on_change)
  310.  
  311.         self.selector = gtk.combo_box_new_text()
  312.         
  313.         
  314.         selected = None
  315.         for nr, choice in enumerate(supported):
  316.             self.selector.append_text(str(choice))
  317.             if str (value) == str (choice):
  318.                 selected = nr
  319.         if selected is not None:
  320.             self.selector.set_active(selected)
  321.         else:
  322.             print "Unknown value for %s: %s" % (name, value)
  323.             print "Choices:", supported
  324.         self.selector.connect("changed", self.changed)
  325.  
  326.     def get_current_value(self):
  327.         return self.selector.get_active_text()
  328.  
  329. # ---------------------------------------------------------------------------
  330.  
  331. class OptionSelectOneNumber(OptionSelectOne):
  332.  
  333.     def get_current_value(self):
  334.         return int(self.selector.get_active_text())
  335.  
  336. # ---------------------------------------------------------------------------
  337.  
  338. class OptionSelectMany(Option):
  339.  
  340.     def __init__(self, name, value, supported, on_change):
  341.         Option.__init__(self, name, value, supported, on_change)
  342.         self.checkboxes = []
  343.         vbox = gtk.VBox()
  344.  
  345.         for s in supported:
  346.             checkbox = gtk.CheckButton(label=s)
  347.             checkbox.set_active(s in value)
  348.             vbox.add(checkbox)
  349.             checkbox.connect("toggled", self.changed)
  350.             self.checkboxes.append(checkbox)
  351.         self.selector = vbox
  352.             
  353.     def get_current_value(self):
  354.         return[s for s, chk in zip(self.supported, self.checkboxes)
  355.                if chk.get_active()]
  356.  
  357. # ---------------------------------------------------------------------------
  358.  
  359. class OptionNumeric(Option):
  360.     def __init__(self, name, value, supported, on_change):
  361.         self.is_float = (isinstance(supported, float) or
  362.                          (isinstance(supported, tuple) and
  363.                           isinstance(supported[0], float)))
  364.         if self.is_float:
  365.             digits = 2
  366.         else:
  367.             digits = 0
  368.  
  369.         if not isinstance(supported, tuple):
  370.             supported = (0, supported)
  371.         Option.__init__(self, name, value, supported, on_change)
  372.         adj = gtk.Adjustment(value, supported[0], supported[1], 1.0, 5.0, 0.0)
  373.         self.selector = gtk.SpinButton(adj, climb_rate=1.0, digits=digits)
  374.         if not self.is_float:
  375.             self.selector.set_numeric(True)
  376.         self.selector.connect("changed", self.changed)
  377.  
  378.     def get_current_value(self):
  379.         if self.is_float:
  380.             return self.selector.get_value()
  381.         return self.selector.get_value_as_int()
  382.  
  383. # ---------------------------------------------------------------------------
  384.  
  385. class OptionText(Option):
  386.     def __init__(self, name, value, supported, on_change):
  387.         Option.__init__(self, name, value, supported, on_change)
  388.  
  389.         self.selector = gtk.Entry()
  390.         self.selector.set_text(value)
  391.         self.selector.connect("changed", self.changed)
  392.  
  393.     def get_current_value(self):
  394.         return self.selector.get_text()
  395.